//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS SsmSap service.
///
/// This API reference provides descriptions, syntax, and other details about each of the actions and data types for AWS Systems Manager for SAP. The topic for each action shows the API request parameters and responses.
public struct SsmSap: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the SsmSap client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "SsmSap",
            serviceIdentifier: "ssm-sap",
            serviceProtocol: .restjson,
            apiVersion: "2018-05-10",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: SsmSapErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "af-south-1": "ssm-sap.af-south-1.api.aws",
            "ap-east-1": "ssm-sap.ap-east-1.api.aws",
            "ap-northeast-1": "ssm-sap.ap-northeast-1.api.aws",
            "ap-northeast-2": "ssm-sap.ap-northeast-2.api.aws",
            "ap-northeast-3": "ssm-sap.ap-northeast-3.api.aws",
            "ap-south-1": "ssm-sap.ap-south-1.api.aws",
            "ap-south-2": "ssm-sap.ap-south-2.api.aws",
            "ap-southeast-1": "ssm-sap.ap-southeast-1.api.aws",
            "ap-southeast-2": "ssm-sap.ap-southeast-2.api.aws",
            "ap-southeast-3": "ssm-sap.ap-southeast-3.api.aws",
            "ap-southeast-4": "ssm-sap.ap-southeast-4.api.aws",
            "ca-central-1": "ssm-sap.ca-central-1.api.aws",
            "eu-central-1": "ssm-sap.eu-central-1.api.aws",
            "eu-central-2": "ssm-sap.eu-central-2.api.aws",
            "eu-north-1": "ssm-sap.eu-north-1.api.aws",
            "eu-south-1": "ssm-sap.eu-south-1.api.aws",
            "eu-south-2": "ssm-sap.eu-south-2.api.aws",
            "eu-west-1": "ssm-sap.eu-west-1.api.aws",
            "eu-west-2": "ssm-sap.eu-west-2.api.aws",
            "eu-west-3": "ssm-sap.eu-west-3.api.aws",
            "il-central-1": "ssm-sap.il-central-1.api.aws",
            "me-central-1": "ssm-sap.me-central-1.api.aws",
            "me-south-1": "ssm-sap.me-south-1.api.aws",
            "sa-east-1": "ssm-sap.sa-east-1.api.aws",
            "us-east-1": "ssm-sap.us-east-1.api.aws",
            "us-east-2": "ssm-sap.us-east-2.api.aws",
            "us-west-1": "ssm-sap.us-west-1.api.aws",
            "us-west-2": "ssm-sap.us-west-2.api.aws"
        ]),
        [.dualstack, .fips]: .init(endpoints: [
            "ca-central-1": "ssm-sap-fips.ca-central-1.api.aws",
            "us-east-1": "ssm-sap-fips.us-east-1.api.aws",
            "us-east-2": "ssm-sap-fips.us-east-2.api.aws",
            "us-west-1": "ssm-sap-fips.us-west-1.api.aws",
            "us-west-2": "ssm-sap-fips.us-west-2.api.aws"
        ]),
        [.fips]: .init(endpoints: [
            "ca-central-1": "ssm-sap-fips.ca-central-1.amazonaws.com",
            "us-east-1": "ssm-sap-fips.us-east-1.amazonaws.com",
            "us-east-2": "ssm-sap-fips.us-east-2.amazonaws.com",
            "us-west-1": "ssm-sap-fips.us-west-1.amazonaws.com",
            "us-west-2": "ssm-sap-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Removes permissions associated with the target database.
    @Sendable
    @inlinable
    public func deleteResourcePermission(_ input: DeleteResourcePermissionInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourcePermissionOutput {
        try await self.client.execute(
            operation: "DeleteResourcePermission", 
            path: "/delete-resource-permission", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes permissions associated with the target database.
    ///
    /// Parameters:
    ///   - actionType: Delete or restore the permissions on the target database.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - sourceResourceArn: The Amazon Resource Name (ARN) of the source resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourcePermission(
        actionType: PermissionActionType? = nil,
        resourceArn: String,
        sourceResourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourcePermissionOutput {
        let input = DeleteResourcePermissionInput(
            actionType: actionType, 
            resourceArn: resourceArn, 
            sourceResourceArn: sourceResourceArn
        )
        return try await self.deleteResourcePermission(input, logger: logger)
    }

    /// Deregister an SAP application with AWS Systems Manager for SAP. This action does not aﬀect the existing setup of your SAP workloads on Amazon EC2.
    @Sendable
    @inlinable
    public func deregisterApplication(_ input: DeregisterApplicationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterApplicationOutput {
        try await self.client.execute(
            operation: "DeregisterApplication", 
            path: "/deregister-application", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deregister an SAP application with AWS Systems Manager for SAP. This action does not aﬀect the existing setup of your SAP workloads on Amazon EC2.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterApplication(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterApplicationOutput {
        let input = DeregisterApplicationInput(
            applicationId: applicationId
        )
        return try await self.deregisterApplication(input, logger: logger)
    }

    /// Gets an application registered with AWS Systems Manager for SAP. It also returns the components of the application.
    @Sendable
    @inlinable
    public func getApplication(_ input: GetApplicationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApplicationOutput {
        try await self.client.execute(
            operation: "GetApplication", 
            path: "/get-application", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets an application registered with AWS Systems Manager for SAP. It also returns the components of the application.
    ///
    /// Parameters:
    ///   - applicationArn: The Amazon Resource Name (ARN) of the application.
    ///   - applicationId: The ID of the application.
    ///   - appRegistryArn: The Amazon Resource Name (ARN) of the application registry.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApplication(
        applicationArn: String? = nil,
        applicationId: String? = nil,
        appRegistryArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApplicationOutput {
        let input = GetApplicationInput(
            applicationArn: applicationArn, 
            applicationId: applicationId, 
            appRegistryArn: appRegistryArn
        )
        return try await self.getApplication(input, logger: logger)
    }

    /// Gets the component of an application registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func getComponent(_ input: GetComponentInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetComponentOutput {
        try await self.client.execute(
            operation: "GetComponent", 
            path: "/get-component", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the component of an application registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - componentId: The ID of the component.
    ///   - logger: Logger use during operation
    @inlinable
    public func getComponent(
        applicationId: String,
        componentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetComponentOutput {
        let input = GetComponentInput(
            applicationId: applicationId, 
            componentId: componentId
        )
        return try await self.getComponent(input, logger: logger)
    }

    /// Gets the details of a configuration check operation by specifying the operation ID.
    @Sendable
    @inlinable
    public func getConfigurationCheckOperation(_ input: GetConfigurationCheckOperationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConfigurationCheckOperationOutput {
        try await self.client.execute(
            operation: "GetConfigurationCheckOperation", 
            path: "/get-configuration-check-operation", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of a configuration check operation by specifying the operation ID.
    ///
    /// Parameters:
    ///   - operationId: The ID of the configuration check operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConfigurationCheckOperation(
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConfigurationCheckOperationOutput {
        let input = GetConfigurationCheckOperationInput(
            operationId: operationId
        )
        return try await self.getConfigurationCheckOperation(input, logger: logger)
    }

    /// Gets the SAP HANA database of an application registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func getDatabase(_ input: GetDatabaseInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDatabaseOutput {
        try await self.client.execute(
            operation: "GetDatabase", 
            path: "/get-database", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the SAP HANA database of an application registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - componentId: The ID of the component.
    ///   - databaseArn: The Amazon Resource Name (ARN) of the database.
    ///   - databaseId: The ID of the database.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDatabase(
        applicationId: String? = nil,
        componentId: String? = nil,
        databaseArn: String? = nil,
        databaseId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDatabaseOutput {
        let input = GetDatabaseInput(
            applicationId: applicationId, 
            componentId: componentId, 
            databaseArn: databaseArn, 
            databaseId: databaseId
        )
        return try await self.getDatabase(input, logger: logger)
    }

    /// Gets the details of an operation by specifying the operation ID.
    @Sendable
    @inlinable
    public func getOperation(_ input: GetOperationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOperationOutput {
        try await self.client.execute(
            operation: "GetOperation", 
            path: "/get-operation", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the details of an operation by specifying the operation ID.
    ///
    /// Parameters:
    ///   - operationId: The ID of the operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOperation(
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOperationOutput {
        let input = GetOperationInput(
            operationId: operationId
        )
        return try await self.getOperation(input, logger: logger)
    }

    /// Gets permissions associated with the target database.
    @Sendable
    @inlinable
    public func getResourcePermission(_ input: GetResourcePermissionInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourcePermissionOutput {
        try await self.client.execute(
            operation: "GetResourcePermission", 
            path: "/get-resource-permission", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets permissions associated with the target database.
    ///
    /// Parameters:
    ///   - actionType: 
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourcePermission(
        actionType: PermissionActionType? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourcePermissionOutput {
        let input = GetResourcePermissionInput(
            actionType: actionType, 
            resourceArn: resourceArn
        )
        return try await self.getResourcePermission(input, logger: logger)
    }

    /// Lists all the applications registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listApplications(_ input: ListApplicationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListApplicationsOutput {
        try await self.client.execute(
            operation: "ListApplications", 
            path: "/list-applications", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the applications registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - filters: The filter of name, value, and operator.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listApplications(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListApplicationsOutput {
        let input = ListApplicationsInput(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listApplications(input, logger: logger)
    }

    /// Lists all the components registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listComponents(_ input: ListComponentsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListComponentsOutput {
        try await self.client.execute(
            operation: "ListComponents", 
            path: "/list-components", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the components registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listComponents(
        applicationId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListComponentsOutput {
        let input = ListComponentsInput(
            applicationId: applicationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listComponents(input, logger: logger)
    }

    /// Lists all configuration check types supported by AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listConfigurationCheckDefinitions(_ input: ListConfigurationCheckDefinitionsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConfigurationCheckDefinitionsOutput {
        try await self.client.execute(
            operation: "ListConfigurationCheckDefinitions", 
            path: "/list-configuration-check-definitions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all configuration check types supported by AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConfigurationCheckDefinitions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConfigurationCheckDefinitionsOutput {
        let input = ListConfigurationCheckDefinitionsInput(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConfigurationCheckDefinitions(input, logger: logger)
    }

    /// Lists the configuration check operations performed by AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listConfigurationCheckOperations(_ input: ListConfigurationCheckOperationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConfigurationCheckOperationsOutput {
        try await self.client.execute(
            operation: "ListConfigurationCheckOperations", 
            path: "/list-configuration-check-operations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the configuration check operations performed by AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - filters: The filters of an operation.
    ///   - listMode: The mode for listing configuration check operations. Defaults to "LATEST_PER_CHECK".   LATEST_PER_CHECK - Will list the latest configuration check operation per check type.   ALL_OPERATIONS - Will list all configuration check operations performed on the application.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConfigurationCheckOperations(
        applicationId: String,
        filters: [Filter]? = nil,
        listMode: ConfigurationCheckOperationListingMode? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConfigurationCheckOperationsOutput {
        let input = ListConfigurationCheckOperationsInput(
            applicationId: applicationId, 
            filters: filters, 
            listMode: listMode, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConfigurationCheckOperations(input, logger: logger)
    }

    /// Lists the SAP HANA databases of an application registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listDatabases(_ input: ListDatabasesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDatabasesOutput {
        try await self.client.execute(
            operation: "ListDatabases", 
            path: "/list-databases", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the SAP HANA databases of an application registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - componentId: The ID of the component.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDatabases(
        applicationId: String? = nil,
        componentId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDatabasesOutput {
        let input = ListDatabasesInput(
            applicationId: applicationId, 
            componentId: componentId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDatabases(input, logger: logger)
    }

    /// Returns a list of operations events. Available parameters include OperationID, as well as optional parameters MaxResults, NextToken, and Filters.
    @Sendable
    @inlinable
    public func listOperationEvents(_ input: ListOperationEventsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOperationEventsOutput {
        try await self.client.execute(
            operation: "ListOperationEvents", 
            path: "/list-operation-events", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of operations events. Available parameters include OperationID, as well as optional parameters MaxResults, NextToken, and Filters.
    ///
    /// Parameters:
    ///   - filters: Optionally specify filters to narrow the returned operation event items. Valid filter names include status, resourceID, and resourceType. The valid operator for all three filters is Equals.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - nextToken: The token to use to retrieve the next page of results. This value is null when there are no more results to return.
    ///   - operationId: The ID of the operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOperationEvents(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOperationEventsOutput {
        let input = ListOperationEventsInput(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            operationId: operationId
        )
        return try await self.listOperationEvents(input, logger: logger)
    }

    /// Lists the operations performed by AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listOperations(_ input: ListOperationsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOperationsOutput {
        try await self.client.execute(
            operation: "ListOperations", 
            path: "/list-operations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the operations performed by AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - filters: The filters of an operation.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - nextToken: The token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOperations(
        applicationId: String,
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOperationsOutput {
        let input = ListOperationsInput(
            applicationId: applicationId, 
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOperations(input, logger: logger)
    }

    /// Lists the sub-check results of a specified configuration check operation.
    @Sendable
    @inlinable
    public func listSubCheckResults(_ input: ListSubCheckResultsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSubCheckResultsOutput {
        try await self.client.execute(
            operation: "ListSubCheckResults", 
            path: "/list-sub-check-results", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the sub-check results of a specified configuration check operation.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - nextToken: The token for the next page of results.
    ///   - operationId: The ID of the configuration check operation.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSubCheckResults(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSubCheckResultsOutput {
        let input = ListSubCheckResultsInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            operationId: operationId
        )
        return try await self.listSubCheckResults(input, logger: logger)
    }

    /// Lists the rules of a specified sub-check belonging to a configuration check operation.
    @Sendable
    @inlinable
    public func listSubCheckRuleResults(_ input: ListSubCheckRuleResultsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSubCheckRuleResultsOutput {
        try await self.client.execute(
            operation: "ListSubCheckRuleResults", 
            path: "/list-sub-check-rule-results", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the rules of a specified sub-check belonging to a configuration check operation.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - nextToken: The token for the next page of results.
    ///   - subCheckResultId: The ID of the sub check result.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSubCheckRuleResults(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        subCheckResultId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSubCheckRuleResultsOutput {
        let input = ListSubCheckRuleResultsInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            subCheckResultId: subCheckResultId
        )
        return try await self.listSubCheckRuleResults(input, logger: logger)
    }

    /// Lists all tags on an SAP HANA application and/or database registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all tags on an SAP HANA application and/or database registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Adds permissions to the target database.
    @Sendable
    @inlinable
    public func putResourcePermission(_ input: PutResourcePermissionInput, logger: Logger = AWSClient.loggingDisabled) async throws -> PutResourcePermissionOutput {
        try await self.client.execute(
            operation: "PutResourcePermission", 
            path: "/put-resource-permission", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds permissions to the target database.
    ///
    /// Parameters:
    ///   - actionType: 
    ///   - resourceArn: 
    ///   - sourceResourceArn: 
    ///   - logger: Logger use during operation
    @inlinable
    public func putResourcePermission(
        actionType: PermissionActionType,
        resourceArn: String,
        sourceResourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutResourcePermissionOutput {
        let input = PutResourcePermissionInput(
            actionType: actionType, 
            resourceArn: resourceArn, 
            sourceResourceArn: sourceResourceArn
        )
        return try await self.putResourcePermission(input, logger: logger)
    }

    /// Register an SAP application with AWS Systems Manager for SAP. You must meet the following requirements before registering.  The SAP application you want to register with AWS Systems Manager for SAP is running on Amazon EC2. AWS Systems Manager Agent must be setup on an Amazon EC2 instance along with the required IAM permissions. Amazon EC2 instance(s) must have access to the secrets created in AWS Secrets Manager to manage SAP applications and components.
    @Sendable
    @inlinable
    public func registerApplication(_ input: RegisterApplicationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterApplicationOutput {
        try await self.client.execute(
            operation: "RegisterApplication", 
            path: "/register-application", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Register an SAP application with AWS Systems Manager for SAP. You must meet the following requirements before registering.  The SAP application you want to register with AWS Systems Manager for SAP is running on Amazon EC2. AWS Systems Manager Agent must be setup on an Amazon EC2 instance along with the required IAM permissions. Amazon EC2 instance(s) must have access to the secrets created in AWS Secrets Manager to manage SAP applications and components.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - applicationType: The type of the application.
    ///   - componentsInfo: This is an optional parameter for component details to which the SAP ABAP application is attached, such as Web Dispatcher. This is an array of ApplicationComponent objects. You may input 0 to 5 items.
    ///   - credentials: The credentials of the SAP application.
    ///   - databaseArn: The Amazon Resource Name of the SAP HANA database.
    ///   - instances: The Amazon EC2 instances on which your SAP application is running.
    ///   - sapInstanceNumber: The SAP instance number of the application.
    ///   - sid: The System ID of the application.
    ///   - tags: The tags to be attached to the SAP application.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerApplication(
        applicationId: String,
        applicationType: ApplicationType,
        componentsInfo: [ComponentInfo]? = nil,
        credentials: [ApplicationCredential]? = nil,
        databaseArn: String? = nil,
        instances: [String],
        sapInstanceNumber: String? = nil,
        sid: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterApplicationOutput {
        let input = RegisterApplicationInput(
            applicationId: applicationId, 
            applicationType: applicationType, 
            componentsInfo: componentsInfo, 
            credentials: credentials, 
            databaseArn: databaseArn, 
            instances: instances, 
            sapInstanceNumber: sapInstanceNumber, 
            sid: sid, 
            tags: tags
        )
        return try await self.registerApplication(input, logger: logger)
    }

    /// Request is an operation which starts an application. Parameter ApplicationId is required.
    @Sendable
    @inlinable
    public func startApplication(_ input: StartApplicationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StartApplicationOutput {
        try await self.client.execute(
            operation: "StartApplication", 
            path: "/start-application", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Request is an operation which starts an application. Parameter ApplicationId is required.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - logger: Logger use during operation
    @inlinable
    public func startApplication(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartApplicationOutput {
        let input = StartApplicationInput(
            applicationId: applicationId
        )
        return try await self.startApplication(input, logger: logger)
    }

    /// Refreshes a registered application.
    @Sendable
    @inlinable
    public func startApplicationRefresh(_ input: StartApplicationRefreshInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StartApplicationRefreshOutput {
        try await self.client.execute(
            operation: "StartApplicationRefresh", 
            path: "/start-application-refresh", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Refreshes a registered application.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - logger: Logger use during operation
    @inlinable
    public func startApplicationRefresh(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartApplicationRefreshOutput {
        let input = StartApplicationRefreshInput(
            applicationId: applicationId
        )
        return try await self.startApplicationRefresh(input, logger: logger)
    }

    /// Initiates configuration check operations against a specified application.
    @Sendable
    @inlinable
    public func startConfigurationChecks(_ input: StartConfigurationChecksInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StartConfigurationChecksOutput {
        try await self.client.execute(
            operation: "StartConfigurationChecks", 
            path: "/start-configuration-checks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates configuration check operations against a specified application.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - configurationCheckIds: The list of configuration checks to perform.
    ///   - logger: Logger use during operation
    @inlinable
    public func startConfigurationChecks(
        applicationId: String,
        configurationCheckIds: [ConfigurationCheckType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartConfigurationChecksOutput {
        let input = StartConfigurationChecksInput(
            applicationId: applicationId, 
            configurationCheckIds: configurationCheckIds
        )
        return try await self.startConfigurationChecks(input, logger: logger)
    }

    /// Request is an operation to stop an application. Parameter ApplicationId is required. Parameters StopConnectedEntity and IncludeEc2InstanceShutdown are optional.
    @Sendable
    @inlinable
    public func stopApplication(_ input: StopApplicationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StopApplicationOutput {
        try await self.client.execute(
            operation: "StopApplication", 
            path: "/stop-application", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Request is an operation to stop an application. Parameter ApplicationId is required. Parameters StopConnectedEntity and IncludeEc2InstanceShutdown are optional.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - includeEc2InstanceShutdown: Boolean. If included and if set to True, the StopApplication operation will shut down the associated Amazon EC2 instance in addition to the application.
    ///   - stopConnectedEntity: Specify the ConnectedEntityType. Accepted type is DBMS. If this parameter is included, the connected DBMS (Database Management System) will be stopped.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopApplication(
        applicationId: String,
        includeEc2InstanceShutdown: Bool? = nil,
        stopConnectedEntity: ConnectedEntityType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopApplicationOutput {
        let input = StopApplicationInput(
            applicationId: applicationId, 
            includeEc2InstanceShutdown: includeEc2InstanceShutdown, 
            stopConnectedEntity: stopConnectedEntity
        )
        return try await self.stopApplication(input, logger: logger)
    }

    /// Creates tag for a resource by specifying the ARN.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates tag for a resource by specifying the ARN.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags on a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Delete the tags for a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete the tags for a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: Adds/updates or removes credentials for applications registered with AWS Systems Manager for SAP.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the settings of an application registered with AWS Systems Manager for SAP.
    @Sendable
    @inlinable
    public func updateApplicationSettings(_ input: UpdateApplicationSettingsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApplicationSettingsOutput {
        try await self.client.execute(
            operation: "UpdateApplicationSettings", 
            path: "/update-application-settings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the settings of an application registered with AWS Systems Manager for SAP.
    ///
    /// Parameters:
    ///   - applicationId: The ID of the application.
    ///   - backint: Installation of AWS Backint Agent for SAP HANA.
    ///   - credentialsToAddOrUpdate: The credentials to be added or updated.
    ///   - credentialsToRemove: The credentials to be removed.
    ///   - databaseArn: The Amazon Resource Name of the SAP HANA database that replaces the current SAP HANA connection with the SAP_ABAP application.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApplicationSettings(
        applicationId: String,
        backint: BackintConfig? = nil,
        credentialsToAddOrUpdate: [ApplicationCredential]? = nil,
        credentialsToRemove: [ApplicationCredential]? = nil,
        databaseArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApplicationSettingsOutput {
        let input = UpdateApplicationSettingsInput(
            applicationId: applicationId, 
            backint: backint, 
            credentialsToAddOrUpdate: credentialsToAddOrUpdate, 
            credentialsToRemove: credentialsToRemove, 
            databaseArn: databaseArn
        )
        return try await self.updateApplicationSettings(input, logger: logger)
    }
}

extension SsmSap {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: SsmSap, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension SsmSap {
    /// Return PaginatorSequence for operation ``listApplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listApplicationsPaginator(
        _ input: ListApplicationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListApplicationsInput, ListApplicationsOutput> {
        return .init(
            input: input,
            command: self.listApplications,
            inputKey: \ListApplicationsInput.nextToken,
            outputKey: \ListApplicationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listApplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filter of name, value, and operator.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - logger: Logger used for logging
    @inlinable
    public func listApplicationsPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListApplicationsInput, ListApplicationsOutput> {
        let input = ListApplicationsInput(
            filters: filters, 
            maxResults: maxResults
        )
        return self.listApplicationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listComponents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listComponentsPaginator(
        _ input: ListComponentsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListComponentsInput, ListComponentsOutput> {
        return .init(
            input: input,
            command: self.listComponents,
            inputKey: \ListComponentsInput.nextToken,
            outputKey: \ListComponentsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listComponents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The ID of the application.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - logger: Logger used for logging
    @inlinable
    public func listComponentsPaginator(
        applicationId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListComponentsInput, ListComponentsOutput> {
        let input = ListComponentsInput(
            applicationId: applicationId, 
            maxResults: maxResults
        )
        return self.listComponentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listConfigurationCheckDefinitions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfigurationCheckDefinitionsPaginator(
        _ input: ListConfigurationCheckDefinitionsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConfigurationCheckDefinitionsInput, ListConfigurationCheckDefinitionsOutput> {
        return .init(
            input: input,
            command: self.listConfigurationCheckDefinitions,
            inputKey: \ListConfigurationCheckDefinitionsInput.nextToken,
            outputKey: \ListConfigurationCheckDefinitionsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConfigurationCheckDefinitions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfigurationCheckDefinitionsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConfigurationCheckDefinitionsInput, ListConfigurationCheckDefinitionsOutput> {
        let input = ListConfigurationCheckDefinitionsInput(
            maxResults: maxResults
        )
        return self.listConfigurationCheckDefinitionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listConfigurationCheckOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfigurationCheckOperationsPaginator(
        _ input: ListConfigurationCheckOperationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConfigurationCheckOperationsInput, ListConfigurationCheckOperationsOutput> {
        return .init(
            input: input,
            command: self.listConfigurationCheckOperations,
            inputKey: \ListConfigurationCheckOperationsInput.nextToken,
            outputKey: \ListConfigurationCheckOperationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConfigurationCheckOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The ID of the application.
    ///   - filters: The filters of an operation.
    ///   - listMode: The mode for listing configuration check operations. Defaults to "LATEST_PER_CHECK".   LATEST_PER_CHECK - Will list the latest configuration check operation per check type.   ALL_OPERATIONS - Will list all configuration check operations performed on the application.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConfigurationCheckOperationsPaginator(
        applicationId: String,
        filters: [Filter]? = nil,
        listMode: ConfigurationCheckOperationListingMode? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConfigurationCheckOperationsInput, ListConfigurationCheckOperationsOutput> {
        let input = ListConfigurationCheckOperationsInput(
            applicationId: applicationId, 
            filters: filters, 
            listMode: listMode, 
            maxResults: maxResults
        )
        return self.listConfigurationCheckOperationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDatabases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDatabasesPaginator(
        _ input: ListDatabasesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDatabasesInput, ListDatabasesOutput> {
        return .init(
            input: input,
            command: self.listDatabases,
            inputKey: \ListDatabasesInput.nextToken,
            outputKey: \ListDatabasesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDatabases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The ID of the application.
    ///   - componentId: The ID of the component.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDatabasesPaginator(
        applicationId: String? = nil,
        componentId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDatabasesInput, ListDatabasesOutput> {
        let input = ListDatabasesInput(
            applicationId: applicationId, 
            componentId: componentId, 
            maxResults: maxResults
        )
        return self.listDatabasesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOperationEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOperationEventsPaginator(
        _ input: ListOperationEventsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOperationEventsInput, ListOperationEventsOutput> {
        return .init(
            input: input,
            command: self.listOperationEvents,
            inputKey: \ListOperationEventsInput.nextToken,
            outputKey: \ListOperationEventsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOperationEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Optionally specify filters to narrow the returned operation event items. Valid filter names include status, resourceID, and resourceType. The valid operator for all three filters is Equals.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - operationId: The ID of the operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOperationEventsPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOperationEventsInput, ListOperationEventsOutput> {
        let input = ListOperationEventsInput(
            filters: filters, 
            maxResults: maxResults, 
            operationId: operationId
        )
        return self.listOperationEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOperationsPaginator(
        _ input: ListOperationsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOperationsInput, ListOperationsOutput> {
        return .init(
            input: input,
            command: self.listOperations,
            inputKey: \ListOperationsInput.nextToken,
            outputKey: \ListOperationsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOperations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - applicationId: The ID of the application.
    ///   - filters: The filters of an operation.
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value. If you do not specify a value for MaxResults, the request returns 50 items per page by default.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOperationsPaginator(
        applicationId: String,
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOperationsInput, ListOperationsOutput> {
        let input = ListOperationsInput(
            applicationId: applicationId, 
            filters: filters, 
            maxResults: maxResults
        )
        return self.listOperationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSubCheckResults(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSubCheckResultsPaginator(
        _ input: ListSubCheckResultsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSubCheckResultsInput, ListSubCheckResultsOutput> {
        return .init(
            input: input,
            command: self.listSubCheckResults,
            inputKey: \ListSubCheckResultsInput.nextToken,
            outputKey: \ListSubCheckResultsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSubCheckResults(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - operationId: The ID of the configuration check operation.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSubCheckResultsPaginator(
        maxResults: Int? = nil,
        operationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSubCheckResultsInput, ListSubCheckResultsOutput> {
        let input = ListSubCheckResultsInput(
            maxResults: maxResults, 
            operationId: operationId
        )
        return self.listSubCheckResultsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSubCheckRuleResults(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSubCheckRuleResultsPaginator(
        _ input: ListSubCheckRuleResultsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSubCheckRuleResultsInput, ListSubCheckRuleResultsOutput> {
        return .init(
            input: input,
            command: self.listSubCheckRuleResults,
            inputKey: \ListSubCheckRuleResultsInput.nextToken,
            outputKey: \ListSubCheckRuleResultsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSubCheckRuleResults(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return with a single call. To retrieve the remaining results, make another call with the returned nextToken value.
    ///   - subCheckResultId: The ID of the sub check result.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSubCheckRuleResultsPaginator(
        maxResults: Int? = nil,
        subCheckResultId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSubCheckRuleResultsInput, ListSubCheckRuleResultsOutput> {
        let input = ListSubCheckRuleResultsInput(
            maxResults: maxResults, 
            subCheckResultId: subCheckResultId
        )
        return self.listSubCheckRuleResultsPaginator(input, logger: logger)
    }
}

extension SsmSap.ListApplicationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListApplicationsInput {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension SsmSap.ListComponentsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListComponentsInput {
        return .init(
            applicationId: self.applicationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension SsmSap.ListConfigurationCheckDefinitionsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListConfigurationCheckDefinitionsInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension SsmSap.ListConfigurationCheckOperationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListConfigurationCheckOperationsInput {
        return .init(
            applicationId: self.applicationId,
            filters: self.filters,
            listMode: self.listMode,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension SsmSap.ListDatabasesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListDatabasesInput {
        return .init(
            applicationId: self.applicationId,
            componentId: self.componentId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension SsmSap.ListOperationEventsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListOperationEventsInput {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token,
            operationId: self.operationId
        )
    }
}

extension SsmSap.ListOperationsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListOperationsInput {
        return .init(
            applicationId: self.applicationId,
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension SsmSap.ListSubCheckResultsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListSubCheckResultsInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            operationId: self.operationId
        )
    }
}

extension SsmSap.ListSubCheckRuleResultsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> SsmSap.ListSubCheckRuleResultsInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            subCheckResultId: self.subCheckResultId
        )
    }
}
